Java 集合类学习常用工具类

Collections 工具类

这里主要记录一下这个工具类常用的功能

排序操作

public void testSort() {
    System.out.println("原始顺序：" + list);

    // 反转指定 List 集合中元素的顺序
    Collections.reverse(list);
    System.out.println("reverse后顺序：" + list);

    // 对 List 中的元素进行随机排序（洗牌）
    Collections.shuffle(list);
    System.out.println("shuffle后顺序：" + list);

    // 将指定List集合中i处元素和j出元素进行交换
    Collections.swap(list, 1, 3);
    System.out.println("swap后顺序：" + list);

    // 对 List 里的元素根据自然升序排序
    Collections.sort(list);
    System.out.println("sort后顺序：" + list);

    // 自定义比较器进行排序
    Collections.sort(list, (o1, o2) -> o1.value - o2.value);
    System.out.println("自定义顺序：" + list);

    // 将所有元素向右移位指定长度，如果 distance 等于 size 那么结果不变
    Collections.rotate(list, 1);
    System.out.println("rotate后顺序：" + list);
}

查找和替换

public void testSearch() {
    System.out.println("给定的list：" + list);
    System.out.println("max：" + Collections.max(list));
    System.out.println("min：" + Collections.min(list));
    // 返回指定集合中指定对象出现的次数
    System.out.println("frequency：" + Collections.frequency(list, "a李四"));
    // 替换
    Collections.replaceAll(list, "a李四", "aa李四");
    System.out.println("replaceAll之后：" + list);

    // 使用二分搜索法，以获得指定对象在 List 中的索引，前提是集合已经排序
    // 如果 binarySearch 的对象没有排序的话，搜索结果是不确定的
    System.out.println("binarySearch在sort之前：" + Collections.binarySearch(list, "c赵五"));
    Collections.sort(list);

    // sort之后，结果出来了
    System.out.println("binarySearch在sort之后：" + Collections.binarySearch(list, "c赵五"));
    // 使用指定对象填充
    Collections.fill(list, "A");
    System.out.println("fill：" + list);
}

同步控制

Collections 工具类中提供了多个 synchronizedXxx 方法，该方法返回指定集合对象对应的同步对象，从而解决多线程并发访问集合时线程的安全问题。

HashSet、ArrayList、HashMap 都是线程不安全的，如果需要考虑同步，则使用这些方法。这些方法主要有：synchronizedSet、synchronizedSortedSet、synchronizedList、synchronizedMap、synchronizedSortedMap。

注意：在使用迭代方法遍历集合的时候需要手工同步返回的集合。

Map m = Collections.synchronizedMap(new HashMap());
    ...
Set s = m.keySet();  // Needn't be in synchronized block
    ...
synchronized (m) {  // Synchronizing on m, not s!
    Iterator i = s.iterator(); // Must be in synchronized block
    while (i.hasNext())
        foo(i.next());
}

设置不可变集合

Collections 有三类方法可返回一个不可变集合：

emptyXxx()：返回一个空的不可变的集合对象 singletonXxx()：返回一个只包含指定对象的，不可变的集合对象。 unmodifiableXxx()：返回指定集合对象的不可变视图

public void testUnmodifiable() {
    System.out.println("给定的list：" + list);
    List<String> immovabilityList = Collections.unmodifiableList(list);

    immovabilityList.add("再加个试试！"); // 抛出：java.lang.UnsupportedOperationException

    // 这一行不会执行了
    System.out.println(immovabilityList);
}

反转数组

该方法是一个泛型方法：<T> T[] toArray(T[] a); 如果 toArray 方法中没有传递任何参数的话返回的是 Object 类型数组。

String [] s = new String[]{"dog", "lazy", "a", "over", "jumps", "fox", "brown", "quick", "A"};
List<String> list = Arrays.asList(s);
Collections.reverse(list);
s = list.toArray(new String[0]);//没有指定类型的话会报错

这里的 new String[0] 就是起一个模板的作用，指定了返回数组的类型，0 是为了节省空间，因为它只是为了说明返回的类型。

Arrays 工具类

这里只记录最常用的方法

转换操作

将ArrayList转换为数组

String[] stringArray = { "a", "b", "c", "d", "e" };
ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(stringArray));
String[] stringArr = new String[arrayList.size()];
arrayList.toArray(stringArr);
for (String s : stringArr)
    System.out.println(s);

根据数组创建 ArrayList

String[] stringArray = { "a", "b", "c", "d", "e" };
ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(stringArray));
// [a, b, c, d, e]
System.out.println(arrayList);

将数组转换为Set

Set<String> set = new HashSet<String>(Arrays.asList(stringArray));
//[d, e, b, c, a]
System.out.println(set);

数组转成 List（基本类型的装箱操作）

Integer [] myArray = { 1, 2, 3 };
List myList = Arrays.stream(myArray).collect(Collectors.toList());

//基本类型也可以实现转换（依赖 boxed 的装箱操作）
int [] myArray2 = { 1, 2, 3 };
List myList = Arrays.stream(myArray2).boxed().collect(Collectors.toList());

查找与打印

打印数组

int[] intArray = { 1, 2, 3, 4, 5 };
String intArrayString = Arrays.toString(intArray);

// 直接打印,则会打印出引用对象的Hash值 // [I@7150bd4d System.out.println(intArray);

// [1, 2, 3, 4, 5] System.out.println(intArrayString);

> 检查数组是否包含某个值
```java
String[] stringArray = { "a", "b", "c", "d", "e" };
boolean b = Arrays.asList(stringArray).contains("a");
// true
System.out.println(b);

操作数组

声明数组

String[] aArray = new String[5];
String[] bArray = {"a","b","c", "d", "e"};
String[] cArray = new String[]{"a","b","c","d","e"};

数组元素反转

int[] intArray = { 1, 2, 3, 4, 5 };
ArrayUtils.reverse(intArray);
//[5, 4, 3, 2, 1]
System.out.println(Arrays.toString(intArray));

移除元素

int[] intArray = { 1, 2, 3, 4, 5 };
int[] removed = ArrayUtils.removeElement(intArray, 3);//创建新的数组
System.out.println(Arrays.toString(removed));

合并连接两个数组

int[] intArray = { 1, 2, 3, 4, 5 };
int[] intArray2 = { 6, 7, 8, 9, 10 };
// Apache Commons Lang 库
int[] combinedIntArray = ArrayUtils.addAll(intArray, intArray2);

Collections 工具类​

排序操作​

查找和替换​

同步控制​

设置不可变集合​

反转数组​

Arrays 工具类​

转换操作​

查找与打印​

操作数组​